import _asyncToGenerator from '@babel/runtime/helpers/esm/asyncToGenerator';
import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
import _typeof from '@babel/runtime/helpers/esm/typeof';
import { Popconfirm } from 'antd';
import get from 'lodash/get';
import set from 'lodash/set';
import React, { useCallback, useMemo } from 'react';
import Input from '../../Input';
import { DefaultFields } from '../consts';
var _excluded = [
  'render',
  'onChange',
  'changeWithChildrenValue',
  'linkCheckboxValue',
  'key',
  'fieldType',
  'fieldProps',
  'title',
  'required',
  'uniqued',
  'inherit',
];
function _regeneratorRuntime() {
  'use strict';
  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime =
    function _regeneratorRuntime() {
      return exports;
    };
  var exports = {},
    Op = Object.prototype,
    hasOwn = Op.hasOwnProperty,
    defineProperty =
      Object.defineProperty ||
      function (obj, key, desc) {
        obj[key] = desc.value;
      },
    $Symbol = 'function' == typeof Symbol ? Symbol : {},
    iteratorSymbol = $Symbol.iterator || '@@iterator',
    asyncIteratorSymbol = $Symbol.asyncIterator || '@@asyncIterator',
    toStringTagSymbol = $Symbol.toStringTag || '@@toStringTag';
  function define(obj, key, value) {
    return (
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: !0,
        configurable: !0,
        writable: !0,
      }),
      obj[key]
    );
  }
  try {
    define({}, '');
  } catch (err) {
    define = function define(obj, key, value) {
      return (obj[key] = value);
    };
  }
  function wrap(innerFn, outerFn, self, tryLocsList) {
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
      generator = Object.create(protoGenerator.prototype),
      context = new Context(tryLocsList || []);
    return (
      defineProperty(generator, '_invoke', { value: makeInvokeMethod(innerFn, self, context) }),
      generator
    );
  }
  function tryCatch(fn, obj, arg) {
    try {
      return { type: 'normal', arg: fn.call(obj, arg) };
    } catch (err) {
      return { type: 'throw', arg: err };
    }
  }
  exports.wrap = wrap;
  var ContinueSentinel = {};
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}
  var IteratorPrototype = {};
  define(IteratorPrototype, iteratorSymbol, function () {
    return this;
  });
  var getProto = Object.getPrototypeOf,
    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  NativeIteratorPrototype &&
    NativeIteratorPrototype !== Op &&
    hasOwn.call(NativeIteratorPrototype, iteratorSymbol) &&
    (IteratorPrototype = NativeIteratorPrototype);
  var Gp =
    (GeneratorFunctionPrototype.prototype =
    Generator.prototype =
      Object.create(IteratorPrototype));
  function defineIteratorMethods(prototype) {
    ['next', 'throw', 'return'].forEach(function (method) {
      define(prototype, method, function (arg) {
        return this._invoke(method, arg);
      });
    });
  }
  function AsyncIterator(generator, PromiseImpl) {
    function invoke(method, arg, resolve, reject) {
      var record = tryCatch(generator[method], generator, arg);
      if ('throw' !== record.type) {
        var result = record.arg,
          value = result.value;
        return value && 'object' == _typeof(value) && hasOwn.call(value, '__await')
          ? PromiseImpl.resolve(value.__await).then(
              function (value) {
                invoke('next', value, resolve, reject);
              },
              function (err) {
                invoke('throw', err, resolve, reject);
              },
            )
          : PromiseImpl.resolve(value).then(
              function (unwrapped) {
                (result.value = unwrapped), resolve(result);
              },
              function (error) {
                return invoke('throw', error, resolve, reject);
              },
            );
      }
      reject(record.arg);
    }
    var previousPromise;
    defineProperty(this, '_invoke', {
      value: function value(method, arg) {
        function callInvokeWithMethodAndArg() {
          return new PromiseImpl(function (resolve, reject) {
            invoke(method, arg, resolve, reject);
          });
        }
        return (previousPromise = previousPromise
          ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg)
          : callInvokeWithMethodAndArg());
      },
    });
  }
  function makeInvokeMethod(innerFn, self, context) {
    var state = 'suspendedStart';
    return function (method, arg) {
      if ('executing' === state) throw new Error('Generator is already running');
      if ('completed' === state) {
        if ('throw' === method) throw arg;
        return { value: void 0, done: !0 };
      }
      for (context.method = method, context.arg = arg; ; ) {
        var delegate = context.delegate;
        if (delegate) {
          var delegateResult = maybeInvokeDelegate(delegate, context);
          if (delegateResult) {
            if (delegateResult === ContinueSentinel) continue;
            return delegateResult;
          }
        }
        if ('next' === context.method) context.sent = context._sent = context.arg;
        else if ('throw' === context.method) {
          if ('suspendedStart' === state) throw ((state = 'completed'), context.arg);
          context.dispatchException(context.arg);
        } else 'return' === context.method && context.abrupt('return', context.arg);
        state = 'executing';
        var record = tryCatch(innerFn, self, context);
        if ('normal' === record.type) {
          if (
            ((state = context.done ? 'completed' : 'suspendedYield'),
            record.arg === ContinueSentinel)
          )
            continue;
          return { value: record.arg, done: context.done };
        }
        'throw' === record.type &&
          ((state = 'completed'), (context.method = 'throw'), (context.arg = record.arg));
      }
    };
  }
  function maybeInvokeDelegate(delegate, context) {
    var methodName = context.method,
      method = delegate.iterator[methodName];
    if (undefined === method)
      return (
        (context.delegate = null),
        ('throw' === methodName &&
          delegate.iterator.return &&
          ((context.method = 'return'),
          (context.arg = undefined),
          maybeInvokeDelegate(delegate, context),
          'throw' === context.method)) ||
          ('return' !== methodName &&
            ((context.method = 'throw'),
            (context.arg = new TypeError(
              "The iterator does not provide a '" + methodName + "' method",
            )))),
        ContinueSentinel
      );
    var record = tryCatch(method, delegate.iterator, context.arg);
    if ('throw' === record.type)
      return (
        (context.method = 'throw'),
        (context.arg = record.arg),
        (context.delegate = null),
        ContinueSentinel
      );
    var info = record.arg;
    return info
      ? info.done
        ? ((context[delegate.resultName] = info.value),
          (context.next = delegate.nextLoc),
          'return' !== context.method && ((context.method = 'next'), (context.arg = undefined)),
          (context.delegate = null),
          ContinueSentinel)
        : info
      : ((context.method = 'throw'),
        (context.arg = new TypeError('iterator result is not an object')),
        (context.delegate = null),
        ContinueSentinel);
  }
  function pushTryEntry(locs) {
    var entry = { tryLoc: locs[0] };
    1 in locs && (entry.catchLoc = locs[1]),
      2 in locs && ((entry.finallyLoc = locs[2]), (entry.afterLoc = locs[3])),
      this.tryEntries.push(entry);
  }
  function resetTryEntry(entry) {
    var record = entry.completion || {};
    (record.type = 'normal'), delete record.arg, (entry.completion = record);
  }
  function Context(tryLocsList) {
    (this.tryEntries = [{ tryLoc: 'root' }]),
      tryLocsList.forEach(pushTryEntry, this),
      this.reset(!0);
  }
  function values(iterable) {
    if (iterable || '' === iterable) {
      var iteratorMethod = iterable[iteratorSymbol];
      if (iteratorMethod) return iteratorMethod.call(iterable);
      if ('function' == typeof iterable.next) return iterable;
      if (!isNaN(iterable.length)) {
        var i = -1,
          next = function next() {
            for (; ++i < iterable.length; )
              if (hasOwn.call(iterable, i))
                return (next.value = iterable[i]), (next.done = !1), next;
            return (next.value = undefined), (next.done = !0), next;
          };
        return (next.next = next);
      }
    }
    throw new TypeError(_typeof(iterable) + ' is not iterable');
  }
  return (
    (GeneratorFunction.prototype = GeneratorFunctionPrototype),
    defineProperty(Gp, 'constructor', { value: GeneratorFunctionPrototype, configurable: !0 }),
    defineProperty(GeneratorFunctionPrototype, 'constructor', {
      value: GeneratorFunction,
      configurable: !0,
    }),
    (GeneratorFunction.displayName = define(
      GeneratorFunctionPrototype,
      toStringTagSymbol,
      'GeneratorFunction',
    )),
    (exports.isGeneratorFunction = function (genFun) {
      var ctor = 'function' == typeof genFun && genFun.constructor;
      return (
        !!ctor &&
        (ctor === GeneratorFunction || 'GeneratorFunction' === (ctor.displayName || ctor.name))
      );
    }),
    (exports.mark = function (genFun) {
      return (
        Object.setPrototypeOf
          ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype)
          : ((genFun.__proto__ = GeneratorFunctionPrototype),
            define(genFun, toStringTagSymbol, 'GeneratorFunction')),
        (genFun.prototype = Object.create(Gp)),
        genFun
      );
    }),
    (exports.awrap = function (arg) {
      return { __await: arg };
    }),
    defineIteratorMethods(AsyncIterator.prototype),
    define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
      return this;
    }),
    (exports.AsyncIterator = AsyncIterator),
    (exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
      void 0 === PromiseImpl && (PromiseImpl = Promise);
      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
      return exports.isGeneratorFunction(outerFn)
        ? iter
        : iter.next().then(function (result) {
            return result.done ? result.value : iter.next();
          });
    }),
    defineIteratorMethods(Gp),
    define(Gp, toStringTagSymbol, 'Generator'),
    define(Gp, iteratorSymbol, function () {
      return this;
    }),
    define(Gp, 'toString', function () {
      return '[object Generator]';
    }),
    (exports.keys = function (val) {
      var object = Object(val),
        keys = [];
      for (var key in object) keys.push(key);
      return (
        keys.reverse(),
        function next() {
          for (; keys.length; ) {
            var key = keys.pop();
            if (key in object) return (next.value = key), (next.done = !1), next;
          }
          return (next.done = !0), next;
        }
      );
    }),
    (exports.values = values),
    (Context.prototype = {
      constructor: Context,
      reset: function reset(skipTempReset) {
        if (
          ((this.prev = 0),
          (this.next = 0),
          (this.sent = this._sent = undefined),
          (this.done = !1),
          (this.delegate = null),
          (this.method = 'next'),
          (this.arg = undefined),
          this.tryEntries.forEach(resetTryEntry),
          !skipTempReset)
        )
          for (var name in this)
            't' === name.charAt(0) &&
              hasOwn.call(this, name) &&
              !isNaN(+name.slice(1)) &&
              (this[name] = undefined);
      },
      stop: function stop() {
        this.done = !0;
        var rootRecord = this.tryEntries[0].completion;
        if ('throw' === rootRecord.type) throw rootRecord.arg;
        return this.rval;
      },
      dispatchException: function dispatchException(exception) {
        if (this.done) throw exception;
        var context = this;
        function handle(loc, caught) {
          return (
            (record.type = 'throw'),
            (record.arg = exception),
            (context.next = loc),
            caught && ((context.method = 'next'), (context.arg = undefined)),
            !!caught
          );
        }
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i],
            record = entry.completion;
          if ('root' === entry.tryLoc) return handle('end');
          if (entry.tryLoc <= this.prev) {
            var hasCatch = hasOwn.call(entry, 'catchLoc'),
              hasFinally = hasOwn.call(entry, 'finallyLoc');
            if (hasCatch && hasFinally) {
              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
            } else if (hasCatch) {
              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
            } else {
              if (!hasFinally) throw new Error('try statement without catch or finally');
              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
            }
          }
        }
      },
      abrupt: function abrupt(type, arg) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (
            entry.tryLoc <= this.prev &&
            hasOwn.call(entry, 'finallyLoc') &&
            this.prev < entry.finallyLoc
          ) {
            var finallyEntry = entry;
            break;
          }
        }
        finallyEntry &&
          ('break' === type || 'continue' === type) &&
          finallyEntry.tryLoc <= arg &&
          arg <= finallyEntry.finallyLoc &&
          (finallyEntry = null);
        var record = finallyEntry ? finallyEntry.completion : {};
        return (
          (record.type = type),
          (record.arg = arg),
          finallyEntry
            ? ((this.method = 'next'), (this.next = finallyEntry.finallyLoc), ContinueSentinel)
            : this.complete(record)
        );
      },
      complete: function complete(record, afterLoc) {
        if ('throw' === record.type) throw record.arg;
        return (
          'break' === record.type || 'continue' === record.type
            ? (this.next = record.arg)
            : 'return' === record.type
            ? ((this.rval = this.arg = record.arg), (this.method = 'return'), (this.next = 'end'))
            : 'normal' === record.type && afterLoc && (this.next = afterLoc),
          ContinueSentinel
        );
      },
      finish: function finish(finallyLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.finallyLoc === finallyLoc)
            return (
              this.complete(entry.completion, entry.afterLoc),
              resetTryEntry(entry),
              ContinueSentinel
            );
        }
      },
      catch: function _catch(tryLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.tryLoc === tryLoc) {
            var record = entry.completion;
            if ('throw' === record.type) {
              var thrown = record.arg;
              resetTryEntry(entry);
            }
            return thrown;
          }
        }
        throw new Error('illegal catch attempt');
      },
      delegateYield: function delegateYield(iterable, resultName, nextLoc) {
        return (
          (this.delegate = {
            iterator: values(iterable),
            resultName: resultName,
            nextLoc: nextLoc,
          }),
          'next' === this.method && (this.arg = undefined),
          ContinueSentinel
        );
      },
    }),
    exports
  );
}
export default function useColumns(form, _ref) {
  var columnsProp = _ref.columns,
    _ref$usingCustomActio = _ref.usingCustomActionColumn,
    usingCustomActionColumn = _ref$usingCustomActio === void 0 ? false : _ref$usingCustomActio,
    name = _ref.name,
    uniqueKey = _ref.uniqueKey,
    extraFieldNamesForSubmit = _ref.extraFieldNamesForSubmit,
    rowExpandable = _ref.rowExpandable,
    rowExpandAutoAdd = _ref.rowExpandAutoAdd,
    _ref$addable = _ref.addable,
    addable = _ref$addable === void 0 ? true : _ref$addable,
    addItem = _ref.addItem,
    removeItem = _ref.removeItem,
    _setParentValue = _ref.setParentValue,
    _setChildrenValue = _ref.setChildrenValue,
    Fields = _ref.Fields;
  var getActionColumn = useCallback(
    function () {
      return {
        title: '操作',
        key: 'actions',
        dataIndex: 'actions',
        width: 120,
        render: function render(_, row) {
          var removeNode = /*#__PURE__*/ React.createElement(
            Popconfirm,
            {
              key: 'remove',
              title: '\u60A8\u786E\u8BA4\u5220\u9664\u5417\uFF1F',
              onConfirm: function onConfirm() {
                return removeItem(row);
              },
            },
            /*#__PURE__*/ React.createElement('a', null, '\u5220\u9664'),
          );
          var nodes;
          if (rowExpandable === null || rowExpandable === void 0 ? void 0 : rowExpandable(row)) {
            nodes = [
              /*#__PURE__*/ React.createElement(
                'a',
                {
                  key: 'add',
                  onClick: function onClick() {
                    return addItem(row);
                  },
                  style: {
                    marginRight: 5,
                  },
                },
                '\u65B0\u589E',
              ),
              removeNode,
            ];
          } else {
            nodes = removeNode;
          }
          return nodes;
        },
      };
    },
    [addItem, removeItem, rowExpandable],
  );
  var renderExtraFields = useCallback(
    function (fieldNamePrefix) {
      return [uniqueKey]
        .concat(_toConsumableArray(extraFieldNamesForSubmit || []), ['_vid'])
        .map(function (extraFieldName) {
          var name = [].concat(_toConsumableArray(fieldNamePrefix), [extraFieldName]);
          // @ts-ignore
          return /*#__PURE__*/ React.createElement(Input, {
            key: name.join(''),
            name: name,
            hidden: true,
            required: false,
          });
        });
    },
    [uniqueKey, extraFieldNamesForSubmit],
  );
  var columns = useMemo(
    function () {
      var fieldColumns = columnsProp.map(function (column, columnIndex) {
        var originRender = column.render,
          originOnChange = column.onChange,
          changeWithChildrenValue = column.changeWithChildrenValue,
          linkCheckboxValue = column.linkCheckboxValue,
          key = column.key,
          fieldType = column.fieldType,
          _column$fieldProps = column.fieldProps,
          fieldProps = _column$fieldProps === void 0 ? {} : _column$fieldProps,
          title = column.title,
          required = column.required,
          uniqued = column.uniqued,
          inherit = column.inherit,
          rest = _objectWithoutProperties(column, _excluded);
        var render;
        if (originRender) {
          render = originRender;
        } else if (fieldType) {
          var Field = Fields && Fields[fieldType] ? Fields[fieldType] : DefaultFields[fieldType];
          var placeholderPrefix = ['select', 'cascader'].includes(fieldType) ? '请选择' : '请输入';
          render = function render(_, row) {
            if (inherit && row._parent) {
              return /*#__PURE__*/ React.createElement(
                'div',
                {
                  style: {
                    textAlign: 'center',
                  },
                },
                '\u540C\u4E0A',
              );
            }
            var fieldNamePrefix = [name].concat(_toConsumableArray(row.fieldNamePrefix || []));
            var fieldName = [].concat(_toConsumableArray(fieldNamePrefix), [key]);
            var restFieldProps = typeof fieldProps === 'function' ? fieldProps(row) : fieldProps;
            if (
              uniqued &&
              (!restFieldProps.rules ||
                !restFieldProps.rules.length ||
                // @ts-ignore
                !restFieldProps.rules.some(function (rule) {
                  return rule._attachUniqued;
                }))
            ) {
              restFieldProps.rules = [].concat(_toConsumableArray(restFieldProps.rules || []), [
                {
                  validator: (function () {
                    var _validator = _asyncToGenerator(
                      /*#__PURE__*/ _regeneratorRuntime().mark(function _callee(rule, value) {
                        var rowValues, filtered;
                        return _regeneratorRuntime().wrap(function _callee$(_context) {
                          while (1)
                            switch ((_context.prev = _context.next)) {
                              case 0:
                                rowValues = !row._parent
                                  ? form.getFieldValue(name)
                                  : form.getFieldValue(
                                      [name].concat(
                                        _toConsumableArray(row._parent.childFieldNamePrefix),
                                      ),
                                    );
                                filtered = (rowValues || []).filter(function (rowValue) {
                                  return rowValue[key] === value;
                                });
                                if (
                                  !(
                                    (filtered === null || filtered === void 0
                                      ? void 0
                                      : filtered.length) > 1
                                  )
                                ) {
                                  _context.next = 4;
                                  break;
                                }
                                throw new Error(
                                  '\u540C\u4E00\u5C42\u7EA7\u4E0D\u80FD\u6709\u76F8\u540C\u7684'.concat(
                                    title,
                                  ),
                                );
                              case 4:
                              case 'end':
                                return _context.stop();
                            }
                        }, _callee);
                      }),
                    );
                    function validator(_x, _x2) {
                      return _validator.apply(this, arguments);
                    }
                    return validator;
                  })(),
                  _attachUniqued: true,
                },
              ]);
            }
            var fieldNode = /*#__PURE__*/ React.createElement(
              Field,
              _objectSpread(
                _objectSpread(
                  {
                    placeholder: ''.concat(placeholderPrefix).concat(title),
                    required: required,
                  },
                  restFieldProps,
                ),
                {},
                {
                  key: fieldName.join(''),
                  name: fieldName,
                  label: title,
                  onChange: function onChange() {
                    var value = form.getFieldValue(name) || [];
                    var newValue = _toConsumableArray(value);
                    var rowValue = form.getFieldValue(fieldNamePrefix);
                    var childrenName = [].concat(_toConsumableArray(row.fieldNamePrefix || []), [
                      'children',
                    ]);
                    // 如果可展开，满足展开条件时，自动添加一个子节点
                    if (rowExpandable) {
                      var canExpand = rowExpandable(rowValue);
                      if (!canExpand) {
                        set(newValue, childrenName, undefined);
                        form.setFieldsValue(_defineProperty({}, name, newValue));
                      } else if (canExpand && rowExpandAutoAdd) {
                        var children = get(newValue, childrenName);
                        if (
                          !children ||
                          !(children === null || children === void 0 ? void 0 : children.length)
                        )
                          addItem(row);
                      }
                    }
                    /**
                     * 获取同一层级各行节点的值
                     * @param fieldName
                     * @returns
                     */
                    var getSameLevelValues = function getSameLevelValues(fieldName) {
                      var sameLevelNamePrefix = fieldNamePrefix.slice(
                        0,
                        fieldNamePrefix.length - 2,
                      );
                      if (sameLevelNamePrefix.length) {
                        var sameLevelRowValues = form.getFieldValue(
                          [].concat(_toConsumableArray(sameLevelNamePrefix), ['children']),
                        );
                        return fieldName
                          ? sameLevelRowValues.map(function (rowValues) {
                              return rowValues[fieldName];
                            })
                          : sameLevelRowValues;
                      }
                    };
                    // 父节点变更，对子节点设置相同的值
                    if (changeWithChildrenValue) {
                      var fieldValue = form.getFieldValue(fieldName);
                      _setChildrenValue(row, key, fieldValue);
                    }
                    if (fieldType === 'checkbox' && linkCheckboxValue) {
                      // 父节点变更，对子节点设置相同的值
                      var _fieldValue = form.getFieldValue(fieldName);
                      _setChildrenValue(row, key, _fieldValue);
                      var sameLevelCheckedValues = getSameLevelValues(key);
                      if (
                        !!_fieldValue ||
                        (!_fieldValue &&
                          sameLevelCheckedValues.every(function (checked) {
                            return !checked;
                          }))
                      )
                        _setParentValue(row, key, _fieldValue);
                    }
                    if (originOnChange) {
                      var _fieldValue2 = form.getFieldValue(fieldName);
                      originOnChange(fieldName, _fieldValue2, {
                        form: form,
                        addChild: function addChild() {
                          addItem(row);
                        },
                        remove: function remove() {
                          removeItem(row);
                        },
                        setChildrenValue: function setChildrenValue(fName, fValue) {
                          return _setChildrenValue(row, fName, fValue);
                        },
                        setParentValue: function setParentValue(fName, fValue) {
                          return _setParentValue(row, fName, fValue);
                        },
                        getSameLevelValues: getSameLevelValues,
                      });
                    }
                  },
                },
              ),
            );
            return !columnIndex
              ? [fieldNode].concat(_toConsumableArray(renderExtraFields(fieldNamePrefix)))
              : fieldNode;
          };
        }
        return _objectSpread(
          _objectSpread({}, rest),
          {},
          {
            /* @ts-ignore */
            title: required
              ? /*#__PURE__*/ React.createElement(
                  'div',
                  {
                    className: 'required',
                  },
                  title,
                )
              : title,
            key: key,
            dataIndex: key,
            render: render,
          },
        );
      });
      if (usingCustomActionColumn || !addable) return fieldColumns;
      return addable
        ? [].concat(_toConsumableArray(fieldColumns), [getActionColumn()])
        : fieldColumns;
    },
    [
      form,
      columnsProp,
      usingCustomActionColumn,
      rowExpandable,
      renderExtraFields,
      getActionColumn,
      rowExpandAutoAdd,
      addItem,
      _setParentValue,
      _setChildrenValue,
    ],
  );
  return {
    columns: columns,
  };
}
